FastAPI Fayl Yuklashlarni O'zlashtirish: Multipart Form Qayta Ishlashni Chuqur O'rganish

Zamonaviy veb-ilovalarda fayl yuklashlarni qayta ishlash qobiliyati asosiy talab hisoblanadi. Foydalanuvchilar profil rasmlarini yuboradimi, qayta ishlash uchun hujjatlarni taqdim etadimi yoki ulashish uchun media fayllarni yuklaydimi, ishonchli va samarali fayl yuklash mexanizmlari juda muhimdir. Yuqori unumdorlikka ega Python veb-freymvorki bo'lgan FastAPI, HTTP orqali fayllarni yuborish standarti bo'lgan multipart form ma'lumotlarini boshqarishning soddalashtirilgan usullarini taklif qilib, bu sohada ustunlik qiladi. Ushbu keng qamrovli qo'llanma sizni FastAPI fayl yuklashlarining nozikliklari bilan tanishtiradi, oddiy amalga oshirishdan tortib ilg'or mulohazalargacha, bu sizga global auditoriya uchun kuchli va kengaytiriladigan API'larni ishonch bilan yaratish imkonini beradi.

Multipart Form Ma'lumotlarini Tushunish

FastAPI'ning amalga oshirilishiga sho'ng'ishdan oldin, multipart form ma'lumotlari nima ekanligini tushunish muhim. Veb-brauzer fayllarni o'z ichiga olgan formani yuborganida, u odatda enctype="multipart/form-data" atributidan foydalanadi. Ushbu kodlash turi forma yuborilishini bir nechta qismlarga ajratadi, har birining o'z kontent turi va joylashuvi haqida ma'lumotlari mavjud. Bu bitta HTTP so'rovi ichida turli xil ma'lumotlar turlarini, shu jumladan matn maydonlari, matn bo'lmagan maydonlar va binar fayllarni uzatish imkonini beradi.

Multipart so'rovdagi har bir qism quyidagilardan iborat:

• Content-Disposition Sarlavhasi: Forma maydonining nomini (name) va fayllar uchun asl fayl nomini (filename) ko'rsatadi.
• Content-Type Sarlavhasi: Qismning MIME turini ko'rsatadi (masalan, text/plain, image/jpeg).
• Tana (Body): O'sha qism uchun haqiqiy ma'lumotlar.

FastAPI'ning Fayl Yuklashlarga Yondashuvi

FastAPI Python'ning standart kutubxonasidan foydalanadi va ma'lumotlarni tekshirish uchun Pydantic bilan muammosiz integratsiyalashadi. Fayl yuklashlar uchun u fastapi modulidan UploadFile turidan foydalanadi. Bu klass yuklangan fayl ma'lumotlariga kirish uchun qulay va xavfsiz interfeysni ta'minlaydi.

Fayl Yuklashning Asosiy Amalga Oshirilishi

Keling, FastAPI'da bitta fayl yuklashni qabul qiladigan endpoint yaratishning oddiy misolidan boshlaylik. Fayl parametrini e'lon qilish uchun fastapi dan File funksiyasidan foydalanamiz.

            from fastapi import FastAPI, File, UploadFile

app = FastAPI()

@app.post("/files/")
async def create_file(file: UploadFile):
    return {"filename": file.filename, "content_type": file.content_type}

            

              
                Copy
              
            
          

Ushbu misolda:

• Biz FastAPI, File va UploadFile'ni import qilamiz.
• /files/ endpoint'i POST so'rovi sifatida belgilanadi.
• file parametri UploadFile bilan izohlanadi, bu uning fayl yuklashini kutayotganini bildiradi.
• Endpoint funksiyasi ichida biz yuklangan faylning filename va content_type kabi xususiyatlariga kira olamiz.

Mijoz /files/ ga fayl biriktirilgan (odatda enctype="multipart/form-data" bilan forma orqali) POST so'rovini yuborganida, FastAPI avtomatik ravishda tahlil qilishni amalga oshiradi va UploadFile obyektini taqdim etadi. Keyin siz bu obyekt bilan o'zaro ishlashingiz mumkin.

Yuklangan Fayllarni Saqlash

Ko'pincha siz yuklangan faylni diskka saqlashingiz yoki uning tarkibini qayta ishlashingiz kerak bo'ladi. UploadFile obyekti buning uchun usullarni taqdim etadi:

• read(): Faylning butun tarkibini baytlar sifatida xotiraga o'qiydi. Buni kichikroq fayllar uchun ishlating.
• write(content: bytes): Faylga baytlarni yozadi.
• seek(offset: int): Joriy fayl pozitsiyasini o'zgartiradi.
• close(): Faylni yopadi.

Ayniqsa, katta fayllar yoki I/O bilan bog'liq vazifalar bilan ishlaganda fayl operatsiyalarini asinxron tarzda bajarish muhimdir. FastAPI'ning UploadFile'i asinxron operatsiyalarni qo'llab-quvvatlaydi.

            from fastapi import FastAPI, File, UploadFile
import shutil

app = FastAPI()

@app.post("/files/save/")
async def save_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
    return {"info": f"file '{file.filename}' saved at '{file_location}'"}

            

              
                Copy
              
            
          

Ushbu takomillashtirilgan misolda:

• Ushbu parametr talab qilinishini bildirish uchun File(...) dan foydalanamiz.
• Biz fayl saqlanadigan mahalliy yo'lni ko'rsatamiz. uploads katalogi mavjudligiga ishonch hosil qiling.
• Biz manzil faylini binar yozish rejimida ("wb+") ochamiz.
• Biz yuklangan faylning tarkibini await file.read() yordamida asinxron ravishda o'qiymiz va keyin uni mahalliy faylga yozamiz.

Eslatma: Faylning butun tarkibini await file.read() bilan xotiraga o'qish juda katta fayllar uchun muammoli bo'lishi mumkin. Bunday holatlar uchun fayl tarkibini oqim (streaming) orqali uzatishni ko'rib chiqing.

Fayl Tarkibini Oqim Orqali Uzatish (Streaming)

Katta fayllar uchun butun tarkibni xotiraga o'qish ortiqcha xotira sarfiga va xotira yetishmasligi xatolariga olib kelishi mumkin. Xotirani tejaydigan yondashuv faylni qismlarga bo'lib oqim orqali uzatishdir. shutil.copyfileobj funksiyasi buning uchun a'lo darajada ishlaydi, ammo biz uni asinxron operatsiyalar uchun moslashtirishimiz kerak.

            from fastapi import FastAPI, File, UploadFile
import aiofiles # Install using: pip install aiofiles

app = FastAPI()

@app.post("/files/stream/")
async def stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        content = await file.read()
        await out_file.write(content)
    return {"info": f"file '{file.filename}' streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

aiofiles yordamida biz yuklangan fayl tarkibini butun faylni birdaniga xotiraga yuklamasdan samarali tarzda manzil fayliga oqim orqali uzatishimiz mumkin. Bu kontekstdagi await file.read() hali ham butun faylni o'qiydi, ammo aiofiles yozishni yanada samaraliroq bajaradi. UploadFile bilan haqiqiy qismlarga bo'lib oqim uzatish uchun odatda await file.read(chunk_size) bo'ylab iteratsiya qilasiz, ammo aiofiles.open va await out_file.write(content) saqlash uchun keng tarqalgan va samarali usuldir.

Qismlarga bo'lish (chunking) yordamida yanada aniqroq oqim uzatish yondashuvi:

            from fastapi import FastAPI, File, UploadFile
import aiofiles

app = FastAPI()

CHUNK_SIZE = 1024 * 1024 # 1MB chunk size

@app.post("/files/chunked_stream/")
async def chunked_stream_file(file: UploadFile = File(...)):
    file_location = f"./uploads/{file.filename}"
    async with aiofiles.open(file_location, "wb") as out_file:
        while content := await file.read(CHUNK_SIZE):
            await out_file.write(content)
    return {"info": f"file '{file.filename}' chunked streamed and saved at '{file_location}'"}

            

              
                Copy
              
            
          

Ushbu `chunked_stream_file` endpoint'i faylni 1MB'lik qismlarga bo'lib o'qiydi va har bir qismni chiqish fayliga yozadi. Bu potentsial juda katta fayllar bilan ishlashning eng samarali usuli hisoblanadi.

Bir Nechta Fayl Yuklashlarni Boshqarish

Veb-ilovalar ko'pincha foydalanuvchilardan bir vaqtning o'zida bir nechta fayl yuklashni talab qiladi. FastAPI buni osonlashtiradi.

Fayllar Ro'yxatini Yuklash

Parametringizni UploadFile ro'yxati bilan izohlab, fayllar ro'yxatini qabul qilishingiz mumkin.

            from fastapi import FastAPI, File, UploadFile, Form
from typing import List

app = FastAPI()

@app.post("/files/multiple/")
async def create_multiple_files(
    files: List[UploadFile] = File(...)
):
    results = []
    for file in files:
        # Process each file, e.g., save it
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {"files_processed": results}

            

              
                Copy
              
            
          

Bu stsenariyda mijoz bir xil forma maydoni nomi bilan (masalan, `files`) bir nechta qism yuborishi kerak. FastAPI ularni Python'dagi UploadFile obyektlari ro'yxatiga yig'adi.

Fayllar va Boshqa Forma Ma'lumotlarini Aralashtirish

Fayl maydonlari va oddiy matn maydonlarini o'z ichiga olgan formalar keng tarqalgan. FastAPI buni boshqa parametrlarni standart turdagi izohlar bilan birga, fayl bo'lmagan forma maydonlari uchun Form yordamida e'lon qilishga ruxsat berish orqali hal qiladi.

            from fastapi import FastAPI, File, UploadFile, Form
from typing import List

app = FastAPI()

@app.post("/files/mixed/")
async def upload_mixed_data(
    description: str = Form(...),
    files: List[UploadFile] = File(...) # Accepts multiple files with the name 'files'
):
    results = []
    for file in files:
        # Process each file
        file_location = f"./uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())
        results.append({"filename": file.filename, "content_type": file.content_type, "saved_at": file_location})
    return {
        "description": description,
        "files_processed": results
    }

            

              
                Copy
              
            
          

Swagger UI yoki Postman kabi vositalardan foydalanganda, siz description'ni oddiy forma maydoni sifatida belgilaysiz va keyin files maydoni uchun bir nechta qism qo'shasiz, har birining kontent turi tegishli rasm/hujjat turiga o'rnatiladi.

Ilg'or Xususiyatlar va Eng Yaxshi Amaliyotlar

Asosiy fayl ishlashdan tashqari, ishonchli fayl yuklash API'larini yaratish uchun bir nechta ilg'or xususiyatlar va eng yaxshi amaliyotlar muhimdir.

Fayl Hajmi Cheklovlari

Cheksiz fayl yuklashlarga ruxsat berish xizmat ko'rsatishni rad etish (denial-of-service) hujumlariga yoki resurslarning haddan tashqari iste'mol qilinishiga olib kelishi mumkin. FastAPI o'zi freymvork darajasida sukut bo'yicha qattiq cheklovlar qo'ymasa-da, siz tekshiruvlarni amalga oshirishingiz kerak:

• Ilova Darajasida: Fayl qabul qilingandan keyin, lekin qayta ishlash yoki saqlashdan oldin uning hajmini tekshiring.
• Veb-Server/Proksi Darajasida: Veb-serveringizni (masalan, Nginx, Uvicorn ishchilar bilan) ma'lum bir yuklama hajmidan oshib ketadigan so'rovlarni rad etish uchun sozlang.

Ilova darajasidagi hajm tekshiruvi misoli:

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

MAX_FILE_SIZE_MB = 10
MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024

@app.post("/files/limited_size/")
async def upload_with_size_limit(file: UploadFile = File(...)):
    if len(await file.read()) > MAX_FILE_SIZE_BYTES:
        raise HTTPException(status_code=400, detail=f"File is too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
    
    # Reset file pointer to read content again
    await file.seek(0)
    
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully."}

            

              
                Copy
              
            
          

Muhim: Fayl hajmini tekshirish uchun uni o'qib bo'lgach, agar uning tarkibini yana o'qishni rejalashtirmoqchi bo'lsangiz (masalan, uni saqlash uchun), fayl ko'rsatkichini boshiga qaytarish uchun await file.seek(0) dan foydalanishingiz kerak.

Ruxsat Etilgan Fayl Turlari (MIME Turlari)

Yuklashlarni ma'lum fayl turlari bilan cheklash xavfsizlikni oshiradi va ma'lumotlar yaxlitligini ta'minlaydi. Siz UploadFile obyektining content_type atributini tekshirishingiz mumkin.

            from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

ALLOWED_FILE_TYPES = {"image/jpeg", "image/png", "application/pdf"}

@app.post("/files/restricted_types/")
async def upload_restricted_types(file: UploadFile = File(...)):
    if file.content_type not in ALLOWED_FILE_TYPES:
        raise HTTPException(status_code=400, detail=f"Unsupported file type: {file.content_type}. Allowed types are: {', '.join(ALLOWED_FILE_TYPES)}")
        
    # Proceed with saving or processing the file
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())
        
    return {"info": f"File '{file.filename}' uploaded successfully and is of an allowed type."}

            

              
                Copy
              
            
          

Yanada ishonchli tur tekshiruvi uchun, ayniqsa rasmlar uchun, faylning haqiqiy tarkibini tekshirish uchun Pillow kabi kutubxonalardan foydalanishni ko'rib chiqishingiz mumkin, chunki MIME turlari ba'zan qalbakilashtirilishi mumkin.

Xatoliklarni Boshqarish va Foydalanuvchi Fikr-Mulohazasi

Foydalanuvchiga aniq va amaliy xato xabarlarini taqdim eting. Standart HTTP xato javoblari uchun FastAPI'ning HTTPException'idan foydalaning.

• Fayl Topilmadi/Mavjud Emas: Agar talab qilingan fayl parametri yuborilmagan bo'lsa.
• Fayl Hajmi Oshib Ketdi: Hajm cheklovi misolida ko'rsatilganidek.
• Noto'g'ri Fayl Turi: Tur cheklovi misolida ko'rsatilganidek.
• Server Xatolari: Faylni saqlash yoki qayta ishlash paytidagi muammolar uchun (masalan, disk to'lgan, ruxsat xatolari).

Xavfsizlik Mulohazalari

Fayl yuklashlar xavfsizlik xatarlarini keltirib chiqaradi:

• Zararli Fayllar: Boshqa fayl turlari sifatida niqoblangan bajariladigan fayllarni (.exe, .sh) yoki skriptlarni yuklash. Har doim fayl turlarini tekshiring va yuklangan fayllarni zararli dasturlarga qarshi skanerlashni ko'rib chiqing.
• Yo'l Bo'ylab O'tish (Path Traversal): Hujumchilarning fayllarni kutilmagan kataloglarga yuklashini oldini olish uchun fayl nomlarini tozalang (masalan, ../../etc/passwd kabi fayl nomlaridan foydalanish). FastAPI'ning UploadFile'i asosiy fayl nomini tozalashni amalga oshiradi, ammo qo'shimcha ehtiyotkorlik qilish oqilona.
• Xizmat ko'rsatishni rad etish: Fayl hajmi cheklovlarini va ehtimol yuklash endpoint'larida so'rovlar tezligini cheklashni joriy qiling.
• Saytlararo Skripting (XSS): Agar siz fayl nomlarini yoki fayl tarkibini to'g'ridan-to'g'ri veb-sahifada ko'rsatsangiz, XSS hujumlarini oldini olish uchun ularning to'g'ri ekranlanganligiga ishonch hosil qiling.

Eng Yaxshi Amaliyot: Yuklangan fayllarni veb-serveringizning hujjatlar ildizidan tashqarida saqlang va ularni tegishli kirish nazorati bilan maxsus endpoint orqali taqdim eting yoki Kontent Yetkazib Berish Tarmog'idan (CDN) foydalaning.

Fayl Yuklashlar Bilan Pydantic Modellaridan Foydalanish

Fayllar uchun asosiy tur UploadFile bo'lsa-da, siz murakkabroq ma'lumotlar tuzilmalari uchun fayl yuklashlarni Pydantic modellariga integratsiya qilishingiz mumkin. Biroq, standart Pydantic modellari ichidagi to'g'ridan-to'g'ri fayl yuklash maydonlari multipart formalar uchun tabiiy ravishda qo'llab-quvvatlanmaydi. Buning o'rniga, siz odatda faylni alohida parametr sifatida qabul qilasiz va keyin uni Pydantic modeli tomonidan saqlanishi yoki tekshirilishi mumkin bo'lgan formatga qayta ishlaysiz.

Keng tarqalgan usul metadata uchun Pydantic modeliga ega bo'lish va keyin faylni alohida qabul qilishdir:

            from fastapi import FastAPI, File, UploadFile, Form
from pydantic import BaseModel
from typing import Optional

class UploadMetadata(BaseModel):
    title: str
    description: Optional[str] = None

app = FastAPI()

@app.post("/files/model_metadata/")
async def upload_with_metadata(
    metadata: str = Form(...), # Receive metadata as a JSON string
    file: UploadFile = File(...)
):
    import json
    try:
        metadata_obj = UploadMetadata(**json.loads(metadata))
    except json.JSONDecodeError:
        raise HTTPException(status_code=400, detail="Invalid JSON format for metadata")
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"Error parsing metadata: {e}")

    # Now you have metadata_obj and file
    # Proceed with saving file and using metadata
    file_location = f"./uploads/{file.filename}"
    with open(file_location, "wb+") as file_object:
        file_object.write(await file.read())

    return {
        "message": "File uploaded successfully with metadata",
        "metadata": metadata_obj,
        "filename": file.filename
    }

            

              
                Copy
              
            
          

Ushbu usulda mijoz metadatani forma maydoni ichida JSON qatori sifatida (masalan, metadata) va faylni alohida multipart qismi sifatida yuboradi. Keyin server JSON qatorini Pydantic obyektiga tahlil qiladi.

Katta Fayllarni Yuklash va Qismlarga Bo'lish (Chunking)

Juda katta fayllar uchun (masalan, gigabaytlar), hatto oqim uzatish ham veb-server yoki mijoz tomonidagi cheklovlarga duch kelishi mumkin. Yanada ilg'or usul bu qismlarga bo'lib yuklash (chunked uploads) bo'lib, bunda mijoz faylni kichikroq qismlarga bo'ladi va ularni ketma-ket yoki parallel ravishda yuklaydi. Keyin server bu qismlarni qayta yig'adi. Bu odatda maxsus mijoz tomonidagi mantiqni va qismlarni boshqarish uchun mo'ljallangan server endpoint'ini talab qiladi (masalan, qismlarni aniqlash, vaqtinchalik saqlash va yakuniy yig'ish).

FastAPI mijoz tomonidan boshlangan qismlarga bo'lib yuklashlar uchun o'rnatilgan qo'llab-quvvatlashni ta'minlamasa-da, siz bu mantiqni FastAPI endpoint'laringiz ichida amalga oshirishingiz mumkin. Bu quyidagi endpoint'larni yaratishni o'z ichiga oladi:

• Alohida fayl qismlarini qabul qilish.
• Bu qismlarni vaqtinchalik saqlash, ehtimol ularning tartibi va umumiy qismlar sonini ko'rsatuvchi metadata bilan.
• Barcha qismlar yuklanganligini bildirish uchun endpoint yoki mexanizmni ta'minlash, bu qayta yig'ish jarayonini ishga tushiradi.

Bu murakkabroq vazifa bo'lib, ko'pincha mijoz tomonida JavaScript kutubxonalarini jalb qilishni talab qiladi.

Xalqarolashtirish va Globallashtirish Mulohazalari

Global auditoriya uchun API'lar yaratishda fayl yuklashlar alohida e'tiborni talab qiladi:

• Fayl nomlari: Dunyo bo'ylab foydalanuvchilar fayl nomlarida ASCII bo'lmagan belgilardan foydalanishlari mumkin (masalan, urg'ular, ierogliflar). Tizimingiz bu fayl nomlarini to'g'ri boshqarishi va saqlashiga ishonch hosil qiling. UTF-8 kodlashi odatda standart hisoblanadi, ammo chuqur moslashuvchanlik ehtiyotkorlik bilan kodlash/dekodlash va tozalashni talab qilishi mumkin.
• Fayl Hajmi Birliklari: MB va GB keng tarqalgan bo'lsa-da, foydalanuvchilar fayl hajmlarini qanday qabul qilishlariga e'tibor bering. Cheklovlarni foydalanuvchiga qulay tarzda ko'rsatish muhimdir.
• Kontent Turlari: Foydalanuvchilar kamroq tarqalgan MIME turlariga ega fayllarni yuklashlari mumkin. Ruxsat etilgan turlar ro'yxatingiz sizning holatingiz uchun keng qamrovli yoki yetarlicha moslashuvchan ekanligiga ishonch hosil qiling.
• Mintaqaviy Qoidalar: Turli mamlakatlardagi ma'lumotlar joylashuvi qonunlari va qoidalaridan xabardor bo'ling. Yuklangan fayllarni saqlash ushbu qoidalarga rioya qilishni talab qilishi mumkin.
• Foydalanuvchi Interfeysi: Fayllarni yuklash uchun mijoz tomonidagi interfeys intuitiv bo'lishi va foydalanuvchining tili va mahalliy sozlamalarini qo'llab-quvvatlashi kerak.

Test Qilish Uchun Vositalar va Kutubxonalar

Fayl yuklash endpoint'larini test qilish juda muhim. Bu yerda ba'zi keng tarqalgan vositalar keltirilgan:

• Swagger UI (Interaktiv API Hujjatlari): FastAPI avtomatik ravishda Swagger UI hujjatlarini yaratadi. Siz fayl yuklashlarni to'g'ridan-to'g'ri brauzer interfeysidan test qilishingiz mumkin. Fayl kiritish maydonini qidiring va "Fayl tanlash" tugmasini bosing.
• Postman: Mashhur API ishlab chiqish va test qilish vositasi. Fayl yuklash so'rovini yuborish uchun:
• So'rov usulini POST'ga o'rnating.
• API endpoint URL'ingizni kiriting.
• "Body" yorlig'iga o'ting.
• Tur sifatida "form-data" ni tanlang.
• Kalit-qiymat juftliklarida fayl parametringiz nomini kiriting (masalan, file).
• Turni "Text" dan "File" ga o'zgartiring.
• Mahalliy tizimingizdan fayl tanlash uchun "Fayllarni tanlash" tugmasini bosing.
• Agar boshqa forma maydonlaringiz bo'lsa, ularni ham shunga o'xshash tarzda qo'shing, ularning turini "Text" sifatida saqlang.
• So'rovni yuboring.
• cURL: HTTP so'rovlarini amalga oshirish uchun buyruq qatori vositasi.
• Bitta fayl uchun: curl -X POST -F "file=@/path/to/your/local/file.txt" http://localhost:8000/files/
• Bir nechta fayllar uchun: curl -X POST -F "files=@/path/to/file1.txt" -F "files=@/path/to/file2.png" http://localhost:8000/files/multiple/
• Aralash ma'lumotlar uchun: curl -X POST -F "description=My description" -F "files=@/path/to/file.txt" http://localhost:8000/files/mixed/
• Python'ning `requests` kutubxonasi: Dasturiy test qilish uchun.

            import requests

url = "http://localhost:8000/files/save/"
files = {'file': open('/path/to/your/local/file.txt', 'rb')}

response = requests.post(url, files=files)
print(response.json())

# For multiple files
url_multiple = "http://localhost:8000/files/multiple/"
files_multiple = {
    'files': [('file1.txt', open('/path/to/file1.txt', 'rb')),
              ('image.png', open('/path/to/image.png', 'rb'))]
}
response_multiple = requests.post(url_multiple, files=files_multiple)
print(response_multiple.json())

# For mixed data
url_mixed = "http://localhost:8000/files/mixed/"
data = {'description': 'Test description'}
files_mixed = {'files': open('/path/to/another_file.txt', 'rb')}
response_mixed = requests.post(url_mixed, data=data, files=files_mixed)
print(response_mixed.json())

            

              
                Copy
              
            
          

Xulosa

FastAPI multipart fayl yuklashlarni boshqarishning kuchli, samarali va intuitiv usulini taqdim etadi. UploadFile turidan va asinxron dasturlashdan foydalangan holda, dasturchilar fayllarni boshqarish imkoniyatlarini muammosiz birlashtiradigan ishonchli API'lar yaratishi mumkin. Xavfsizlikka ustuvor ahamiyat berishni, tegishli xatoliklarni bartaraf etishni amalga oshirishni va fayl nomi kodlashi va me'yoriy muvofiqlik kabi jihatlarni hisobga olgan holda global foydalanuvchilar bazasining ehtiyojlarini ko'rib chiqishni unutmang.

Siz oddiy rasm almashish xizmatini yoki murakkab hujjatlarni qayta ishlash platformasini yaratayotgan bo'lsangiz ham, FastAPI'ning fayl yuklash xususiyatlarini o'zlashtirish muhim boylik bo'ladi. Uning imkoniyatlarini o'rganishda davom eting, eng yaxshi amaliyotlarni qo'llang va xalqaro auditoriyangiz uchun ajoyib foydalanuvchi tajribasini taqdim eting.